// 数据验证工具类
class Validator {
  // 验证手机号
  static isPhone(phone) {
    const phoneRegex = /^1[3-9]\d{9}$/;
    return phoneRegex.test(phone);
  }

  // 验证邮箱
  static isEmail(email) {
    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
    return emailRegex.test(email);
  }

  // 验证密码强度（至少6位）
  static isPassword(password) {
    return password && password.length >= 6;
  }

  // 验证用户名（3-20位字母数字下划线）
  static isUsername(username) {
    const usernameRegex = /^[a-zA-Z0-9_]{3,20}$/;
    return usernameRegex.test(username);
  }

  // 验证金额（保留2位小数）
  static isAmount(amount) {
    const amountRegex = /^\d+(\.\d{1,2})?$/;
    return amountRegex.test(amount.toString()) && parseFloat(amount) >= 0;
  }

  // 验证日期格式
  static isDate(dateString) {
    const date = new Date(dateString);
    return date instanceof Date && !isNaN(date);
  }

  // 验证必填字段
  static required(value, fieldName) {
    if (value === undefined || value === null || value === '') {
      throw new Error(`${fieldName} 不能为空`);
    }
    return true;
  }

  // 验证字符串长度
  static length(value, min = 0, max = Infinity, fieldName = '字段') {
    if (typeof value !== 'string') {
      throw new Error(`${fieldName} 必须是字符串`);
    }
    if (value.length < min || value.length > max) {
      throw new Error(`${fieldName} 长度必须在 ${min}-${max} 之间`);
    }
    return true;
  }

  // 验证数值范围
  static range(value, min = -Infinity, max = Infinity, fieldName = '字段') {
    const num = parseFloat(value);
    if (isNaN(num)) {
      throw new Error(`${fieldName} 必须是数字`);
    }
    if (num < min || num > max) {
      throw new Error(`${fieldName} 必须在 ${min}-${max} 之间`);
    }
    return true;
  }

  // 验证枚举值
  static in(value, allowedValues, fieldName = '字段') {
    if (!allowedValues.includes(value)) {
      throw new Error(`${fieldName} 必须是以下值之一: ${allowedValues.join(', ')}`);
    }
    return true;
  }

  // 批量验证
  static validate(rules, data) {
    const errors = [];
    
    for (const [field, rule] of Object.entries(rules)) {
      try {
        const value = data[field];
        
        // 必填验证
        if (rule.required && (value === undefined || value === null || value === '')) {
          errors.push(`${rule.label || field} 不能为空`);
          continue;
        }
        
        // 如果字段为空且非必填，跳过其他验证
        if (!rule.required && (value === undefined || value === null || value === '')) {
          continue;
        }
        
        // 类型验证
        if (rule.type) {
          switch (rule.type) {
            case 'phone':
              if (!this.isPhone(value)) {
                errors.push(`${rule.label || field} 格式不正确`);
              }
              break;
            case 'email':
              if (!this.isEmail(value)) {
                errors.push(`${rule.label || field} 格式不正确`);
              }
              break;
            case 'password':
              if (!this.isPassword(value)) {
                errors.push(`${rule.label || field} 至少6位字符`);
              }
              break;
            case 'username':
              if (!this.isUsername(value)) {
                errors.push(`${rule.label || field} 只能包含字母数字下划线，3-20位`);
              }
              break;
            case 'amount':
              if (!this.isAmount(value)) {
                errors.push(`${rule.label || field} 必须是有效金额`);
              }
              break;
            case 'date':
              if (!this.isDate(value)) {
                errors.push(`${rule.label || field} 必须是有效日期`);
              }
              break;
          }
        }
        
        // 长度验证
        if (rule.min !== undefined || rule.max !== undefined) {
          this.length(value, rule.min, rule.max, rule.label || field);
        }
        
        // 范围验证
        if (rule.minValue !== undefined || rule.maxValue !== undefined) {
          this.range(value, rule.minValue, rule.maxValue, rule.label || field);
        }
        
        // 枚举验证
        if (rule.in) {
          this.in(value, rule.in, rule.label || field);
        }
        
      } catch (error) {
        errors.push(error.message);
      }
    }
    
    if (errors.length > 0) {
      const error = new Error('数据验证失败');
      error.name = 'ValidationError';
      error.details = errors;
      throw error;
    }
    
    return true;
  }
}

module.exports = Validator; 